# -*- encoding: utf-8 -*-
# Create your views here.
from django.shortcuts import render
from django.http import HttpResponse, Http404
from app import models
from app import functions
from app import forms
from django.contrib.auth.decorators import login_required
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.models import User
from django.contrib.auth.decorators import user_passes_test
from django.db.models import Q
from django.http import HttpResponseRedirect




peliculas = models.Peliculas.objects.all()
generos = models.Generos.objects.all().order_by('nombre_largo')
valoraciones=models.Valoraciones.objects.all().order_by('valoracion')

import operator
dicc={}
lista_peliculas_valoradas = models.Valoraciones.objects.values('pelicula_id').distinct()
    
for p in lista_peliculas_valoradas:
    dicc[models.Peliculas.objects.get(id=p['pelicula_id'])] = functions.valoracion(p['pelicula_id'])
        
peliculas_ranking = sorted(dicc.iteritems(), key=operator.itemgetter(1), reverse=True)
ranking_first_5 = peliculas_ranking[:5]


def login_user(request):
    global ranking_first_5, generos
    user_post = passwd_post = url = ''
    if 'user' in request.POST and 'passwd' in request.POST:
        user_post = request.POST['user']
        passwd_post = request.POST['passwd']
        url = request.POST['url']
        user = authenticate(username=user_post, password=passwd_post)
        # se comprueba si la autenticación es correcta
        if user is not None:
            if user.is_active:
                message = "%s %s se ha autenticado correctamente" % (user.first_name, user.last_name)
                # se logea al usuario en el sistema
                login(request, user)
            else:
                message = "La contraseña es correcta, pero la cuenta ha sido desactivada"
        else:
            # la autenticación no pudo verificar password y contraseña
            message = "El nombre de usuario o la contraseña son incorrectos"
    else:
        message = "Falta alguno de los campos por rellenar o ambos"
    return render(request, 'login.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'message':message, 'url':url})

@login_required(login_url='/home/')
def logout_user(request):
    from django.contrib.auth import logout
    
    logout(request)
    return HttpResponseRedirect('/home/')

def home(request):
    global ranking_first_5, generos
    peliculas_novedades = models.Peliculas.objects.order_by('-date_create')[:5]
    recomendadas = []
    if request.user.is_authenticated() and models.Valoraciones.objects.filter(usuario_id=request.user.id).count():
        vecindario = functions.vecindario(request.user.id)
        if vecindario:
            # se eliminan de las posibles a recomendar aquellas películas que el usuario haya votado
            peliculas_votadas = models.Valoraciones.objects.filter(usuario_id=request.user.id).values_list('pelicula_id', flat=True).distinct()
            posibles = models.Peliculas.objects.all().exclude(id__in=peliculas_votadas)
            for pelicula in posibles:
                recomendadas.append((pelicula,functions.pred(request.user.id, pelicula, vecindario)))    
    recomendadas_ordered = sorted(recomendadas, key=operator.itemgetter(1), reverse=True)
    return render(request, 'index.html', {'nuevas_peliculas': peliculas_novedades, 'lista_generos':generos, 'lista_peliculas':ranking_first_5, 'recomendadas':recomendadas_ordered[:3]})

def genero(request):
    global ranking_first_5, generos
    if 'g' in request.GET:
        genero_get = request.GET['g']
    else:
        return HttpResponseRedirect('/home/')
    genero = models.Generos.objects.get(nombre_corto=genero_get)
    peliculas_genero = models.Peliculas.objects.filter(genero=genero.id).order_by('titulo')
    page = request.GET.get('page')
    peliculas_pag = functions.paginador(peliculas_genero, page)
    return render(request, 'genero.html', {'genero_selec':genero, 'peliculas_genero':peliculas_pag, 'lista_generos':generos, 'lista_peliculas':ranking_first_5})

def pelicula(request):
    global ranking_first_5, generos
    if request.method == 'POST':
        valor = ''
        pelicula_id = request.POST['pelicula_id']
        if 'valor' in request.POST:
            valor = request.POST['valor']
            usuario_logeado = request.user
            valoracion = models.Valoraciones(usuario_id=usuario_logeado.id,pelicula_id=pelicula_id,valoracion=valor)
            valoracion.save()
        elif 'valor_mod' in request.POST:
            valor_mod = request.POST['valor_mod']
            models.Valoraciones.objects.filter(usuario_id=request.user.id,pelicula_id=pelicula_id).update(valoracion=valor_mod)
        return HttpResponseRedirect('/pelicula/?t='+pelicula_id)
    else:
        message = None
        votada = False
        criticada = False
        nota_usuario = None
        if 't' in request.GET:
            pelicula_id = request.GET['t']
        else:
            return HttpResponseRedirect('/home/')
        pelicula_selec = models.Peliculas.objects.get(id=pelicula_id)
        pelicula_valoracion = functions.valoracion(pelicula_id)
        criticas_selec = models.Criticas.objects.filter(pelicula_id=pelicula_id)[:5]
        criticas_list = []
        for critica in criticas_selec:
            c_id = critica.id
            c_titulo = critica.titulo
            c_nota = models.Valoraciones.objects.get(id=critica.nota_id)
            c_resumen = "" + critica.contenido[:200] + "..."
            c_user = models.User.objects.get(id=critica.usuario_id)
            criticas_list.append((c_id,c_titulo,c_nota.valoracion,c_resumen, c_user))
        if request.user.is_authenticated():
            votada = True
            criticada = True
            if not models.Valoraciones.objects.filter(usuario_id=request.user.id,pelicula_id=pelicula_id).count():
                votada = False
            else:
                nota_usuario = models.Valoraciones.objects.get(usuario_id=request.user.id,pelicula_id=pelicula_id).valoracion
            if not models.Criticas.objects.filter(usuario_id=request.user.id,pelicula_id=pelicula_id).count():
                criticada = False
                
        return render(request, 'pelicula.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'lista_criticas':criticas_list, 'pelicula':pelicula_selec, 'pelicula_valoracion':pelicula_valoracion, 'message':message, 'votada':votada, 'criticada':criticada, 'nota_usuario':nota_usuario})

def peliculas_search(request):
    global ranking_first_5,generos
    palabra = titulo = actor = anyo =  ''
    message = None
    if request.method == 'GET':
        if 'palabra' in request.GET:
            palabra = request.GET['palabra']
            if not palabra:
                message = "Debe rellenar al menos uno de los campos."
                return render(request, 'search_results.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'message':message})
            else:
                if models.Peliculas.objects.filter(titulo__icontains=palabra).count():
                    resultados = models.Peliculas.objects.filter(titulo__icontains=palabra)
                    page = request.GET.get('page')
                    resultados_pag = functions.paginador(resultados, page)
                    return render(request, 'search_results.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'resultados':resultados_pag, 'palabra':palabra, 'message':message})
                else:
                    message = "No se han encontrado resultados que coincidan con los criterios de búsqueda."
                    return render(request, 'search_results.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'message':message})
        elif 'titulo' in request.GET:
            opciones = {}
            campos = [('titulo__icontains',request.GET['titulo']),('director__icontains',request.GET['director']),('actores__icontains',request.GET['actores']),('anyo',request.GET['anyo'])]
            for k,v in campos:
                if v != '':
                    opciones[k]=v
            if opciones:
                if models.Peliculas.objects.filter(**opciones).count():
                    resultados = models.Peliculas.objects.filter(**opciones)
                    page = request.GET.get('page')
                    resultados_pag = functions.paginador(resultados, page)
                    return render(request, 'search_results.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'resultados':resultados_pag, 'message':message, 'titulo':request.GET['titulo'], 'director':request.GET['director'], 'actores':request.GET['actores'], 'anyo':request.GET['anyo']})
                else:
                    message = "No se han encontrado resultados que coincidan con los criterios de búsqueda."
                    return render(request, 'search_results.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'message':message})
            else:
                message = "Debe rellenar al menos uno de los campos."
                return render(request, 'search_results.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'message':message})
        return HttpResponseRedirect('/home/')
    else:
        return HttpResponseRedirect('/home/')

def ranking(request):
    global ranking_first_5,generos, peliculas_ranking
                    
    
    return render(request,'ranking.html', {'lista_peliculas': ranking_first_5,'lista_generos':generos,'dicc':peliculas_ranking[:30]})

def criticas_pelicula(request):
    global ranking_first_5,generos
    if 't' in request.GET:
        pelicula_id = request.GET['t']
    else:
        return HttpResponseRedirect('/home/')     
    pelicula_selec = models.Peliculas.objects.get(id=pelicula_id)
    criticas_selec = models.Criticas.objects.filter(pelicula_id=pelicula_id)
    criticas_list = []
    for critica in criticas_selec:
        c_id = critica.id
        c_titulo = critica.titulo
        c_nota = models.Valoraciones.objects.get(id=critica.nota_id)
        c_resumen = "" + critica.contenido[:200] + "..."
        c_user = critica.usuario
        criticas_list.append((c_id,c_titulo,c_nota.valoracion,c_resumen, c_user))
    page = request.GET.get('page')
    criticas_pag = functions.paginador(criticas_list, page)
    return render(request, 'criticas_pelicula.html',{'lista_peliculas': ranking_first_5, 'pelicula':pelicula_selec,'lista_criticas':criticas_pag,'lista_generos':generos})

def critica(request):
    global  ranking_first_5,generos
    if 'c' in request.GET:
        critica_id = request.GET['c']
    else:
        return HttpResponseRedirect('/home/')
    opciones = False    
    critica_selec=models.Criticas.objects.get(id=critica_id)
    c_nota = models.Valoraciones.objects.get(id=critica_selec.nota_id)
    pelicula_selec = models.Peliculas.objects.get(id=critica_selec.pelicula_id)
    if request.user.id == critica_selec.usuario_id:
        opciones = True
    return render (request, 'critica.html',{'lista_peliculas':ranking_first_5,'pelicula':pelicula_selec, 'opciones':opciones, 'critica':critica_selec, 'nota': c_nota.valoracion, 'lista_generos':generos})

@login_required(login_url='/home/')
def critica_add(request):
    global  ranking_first_5,generos
    
    if request.method == 'POST':
        votada = True
        if request.POST['valorada'] == 'False':
            votada = False
        form = forms.CriticaAddForm(request.POST)
        # tomamos los campos ocultos para la validación del formulario
        pelicula = models.Peliculas.objects.get(id=request.POST['pelicula_id'])
        path = request.POST['path']
        if form.is_valid():
            cd = form.cleaned_data
            # comprobamos si la película ya tiene una valoración
            #if not models.Valoraciones.objects.filter(usuario_id=request.user.id,pelicula_id=pelicula.id).count():
            #    votada = False
            if not votada:
                valoracion = models.Valoraciones(usuario_id=request.user.id,pelicula_id=pelicula.id,valoracion=cd['nota'])
                valoracion.save()
                critica = models.Criticas(usuario_id=request.user.id,pelicula_id=pelicula.id,titulo=cd['titulo'],contenido=cd['contenido'],nota=valoracion)
                critica.save()
            else:
                valoracion = models.Valoraciones.objects.get(usuario_id=request.user.id,pelicula_id=pelicula.id)
                critica = models.Criticas(usuario_id=request.user.id,pelicula_id=pelicula.id,titulo=cd['titulo'],contenido=cd['contenido'],nota=valoracion)
                critica.save()
            message = "Crítica agregada correctamente."
            return render(request, 'critica_add_confirmacion.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'message':message, 'path':path})
        else:
            return render(request, 'critica_add.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'pelicula_selec':pelicula, 'path':path, 'votada':votada, 'form':form})
                    
    else:
        if 't' in request.GET and 'path' in request.GET:
            pelicula_id = request.GET['t']
            path = request.GET['path']
            pelicula_selec = models.Peliculas.objects.get(id=pelicula_id)
            votada = True
            if not models.Valoraciones.objects.filter(usuario_id=request.user.id,pelicula_id=pelicula_id).count():
                votada = False
            # asignamos el valor de votada al campo oculto valorada del formulario
            form = forms.CriticaAddForm(initial={'valorada': votada})
            return render(request, 'critica_add.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'pelicula_selec':pelicula_selec, 'path':path, 'votada':votada, 'form':form})
        else:
            return HttpResponseRedirect('/home/')
        
@login_required(login_url='/home/')
def critica_mod(request):
    if request.method == 'POST':
        form = forms.CriticaModUserForm(request.POST)
        critica_id = int(request.POST['critica_id'])
        critica_db = models.Criticas.objects.get(id=critica_id)
        valoracion_db = models.Valoraciones.objects.get(id=critica_db.nota_id)
        if form.is_valid():
            cd = form.cleaned_data
            datos_actualizados = []
            if critica_db.titulo != cd['titulo']:
                models.Criticas.objects.filter(id=critica_id).update(titulo=cd['titulo'])
                datos_actualizados.append('Título')
            if critica_db.contenido != cd['contenido']:
                models.Criticas.objects.filter(id=critica_id).update(contenido=cd['contenido'])
                datos_actualizados.append('Contenido')
            if valoracion_db.valoracion != cd['nota']:
                models.Valoraciones.objects.filter(id=valoracion_db.id).update(valoracion=cd['nota'])
                datos_actualizados.append('Nota')
            return render(request, 'critica_mod_confirmacion.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'datos_actualizados':datos_actualizados, 'critica':critica_db})
        else:
            return render(request, 'critica_mod.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'form':form, 'critica':critica_db})
    else:
        if 'c' in request.GET:
            c = int(request.GET['c'])
            critica = models.Criticas.objects.get(id=c)
            valoracion = models.Valoraciones.objects.get(id=critica.nota_id)
            if request.user.id != critica.usuario_id:
                return HttpResponseRedirect("/home/")
            form = forms.CriticaModUserForm(initial={'titulo':critica.titulo, 'contenido':critica.contenido, 'nota':valoracion.valoracion})
            return render(request, 'critica_mod.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'form':form, 'critica':critica})
        else:
            return HttpResponseRedirect("/home/")
        
@login_required(login_url='/home/')
def critica_delete(request):
    if 'c' in request.GET:
        previous = request.GET['previous']
        critica_id = int(request.GET['c'])
        critica = models.Criticas.objects.get(id=critica_id)
        if request.user.id != critica.usuario_id:
            return HttpResponseRedirect('/home/')
        return render(request, 'critica_delete.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'critica':critica, 'previous':previous})
    else:
        return HttpResponseRedirect('/home/')

@login_required(login_url='/home/')   
def critica_delete_confirmacion(request):
    if 'c' in request.GET:
        previous = request.GET['previous']
        critica_id = int(request.GET['c'])
        critica = models.Criticas.objects.get(id=critica_id)
        if request.user.id != critica.usuario_id:
            return HttpResponseRedirect('/home/')
        critica.delete()
        message = "La crítica ha sido eliminada con éxito."
        return render(request, 'critica_delete_confirmacion.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'message':message, 'previous':previous})
    else:
        return HttpResponseRedirect('/home/')
    
def registro(request):
    global ranking_first_5, generos, peliculas
    errors = []
        
    if request.method == 'POST':
        form = forms.RegistroForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            if User.objects.filter(username=cd['username']).count():
                errors.append("El nombre de usuario ya existe.")
                return render(request, 'registro_user.html', {'lista_peliculas': ranking_first_5, 'lista_generos':generos, 'form':form, 'errors':errors})
            else:
                generos_peliculas = []
                for genero in generos:
                    peliculas_por_genero = models.Peliculas.objects.filter(genero_id=genero.id).order_by('titulo')
                    generos_peliculas.append((genero,peliculas_por_genero))
                return render(request, 'registro_votacion.html', {'lista_peliculas': ranking_first_5, 'lista_generos':generos, 'generos_peliculas':generos_peliculas, 'username':cd['username'], 'first_name':cd['first_name'], 'last_name':cd['last_name'], 'email':cd['email'], 'passwd':cd['passwd1']})
    else:
        form = forms.RegistroForm()
    return render(request, 'registro_user.html', {'lista_peliculas': ranking_first_5, 'lista_generos':generos, 'form':form})    
    
def registro_votacion(request):
    global ranking_first_5, generos, peliculas
    valoraciones = {}
    count = 0
    errors = []
    if request.method == 'POST':
        if 'username' in request.POST and 'first_name' in request.POST and 'last_name' in request.POST and 'email' in request.POST and 'passwd' in request.POST:
            username = request.POST['username']
            first_name = request.POST['first_name']
            last_name = request.POST['last_name']
            email = request.POST['email']
            passwd = request.POST['passwd']
            
            for k,v in request.POST.iteritems():
                    if k.isdigit():
                        valoraciones[k] = v
                       
            for k in valoraciones.keys():
                if valoraciones[k]!='':
                    count+=1
                
            if count<5:
                errors.append("Debe votar al menos 5 películas")
                generos_peliculas = []
                for genero in generos:
                    peliculas_por_genero = models.Peliculas.objects.filter(genero_id=genero.id).order_by('titulo')
                    generos_peliculas.append((genero,peliculas_por_genero))
                return render(request, "registro_votacion.html", {'lista_peliculas':ranking_first_5, 'generos_peliculas':generos_peliculas, 'lista_generos':generos, 'username':username, 'first_name':first_name, 'last_name':last_name, 'email':email, 'passwd':passwd, 'errors':errors})
            else:
                new_user = User()
                new_user.username = username
                new_user.first_name = first_name
                new_user.last_name = last_name
                new_user.email = email
                new_user.set_password(passwd)
                new_user.save()
                for k in valoraciones.keys():
                    if valoraciones[k]!='':
                        val = int(valoraciones[k])
                        v = models.Valoraciones(usuario_id=new_user.id, pelicula_id=k, valoracion=val)
                        v.save()
                message = "Registro completado. Ahora puede logearse en el sistema con su nombre de usuario y contraseña"
                return render(request, "registro_confirmacion.html", {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'message':message})   
    else:
        return HttpResponseRedirect('/registro-user/')
        
    return render(request, 'registro_user.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'errors':errors})

@login_required(login_url='/home/') 
def perfil(request):
    global ranking_first_5, generos
    if 'u' in request.GET:
        user_id = int(request.GET['u'])
        usuario = User.objects.get(id=user_id)
        config = False
        if request.user.id == user_id:
            config = True
        criticas_db = models.Criticas.objects.filter(usuario_id=user_id).order_by("-id")[:5]
        valoraciones_db = models.Valoraciones.objects.filter(usuario_id=user_id).order_by("-id")[:5]
        criticas = []
        valoraciones = []
        for critica in criticas_db:
            pelicula = models.Peliculas.objects.get(id=critica.pelicula_id)
            valoracion = models.Valoraciones.objects.get(id=critica.nota_id)
            criticas.append((pelicula,critica,valoracion.valoracion))
        for valoracion in valoraciones_db:
            pelicula = models.Peliculas.objects.get(id=valoracion.pelicula_id)
            valoraciones.append((pelicula,valoracion.valoracion))
        # amigos
        amistades = models.Amistades.objects.filter(user1_id=request.user.id)
        amigos = []
        for amistad in amistades:
            amigos.append(User.objects.get(id=amistad.user2_id))
        # amigos recomendados
        amigos_recomendados = []
        if models.Valoraciones.objects.filter(usuario_id=user_id).count():
            for vecino,similitud in functions.vecindario(user_id):
                if not models.Amistades.objects.filter(user1_id=request.user.id,user2_id=vecino.id).count():
                    amigos_recomendados.append((vecino,similitud))
        amigos_recomendados_ordered = sorted(amigos_recomendados, key=operator.itemgetter(1), reverse=True)
        es_amigo = False
        if models.Amistades.objects.filter(user1_id=request.user.id,user2_id=user_id).count():
            es_amigo = True
        return render(request, 'perfil.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'criticas':criticas, 'valoraciones':valoraciones, 'usuario':usuario, 'config':config, 'amigos':sorted(amigos)[:5], 'amigos_recomendados':amigos_recomendados_ordered[:5], 'es_amigo':es_amigo})
    else:
        return HttpResponseRedirect('/home/')

@login_required(login_url='/home/')
def valoraciones_user(request):
    global ranking_first_5, generos
    if 'u' in request.GET or 'page' in request.GET:
        user_id = int(request.GET['u'])
        usuario = User.objects.get(id=user_id)
        valoraciones_db = models.Valoraciones.objects.filter(usuario_id=user_id).order_by("-id")
        valoraciones = []
        for valoracion in valoraciones_db:
            pelicula = models.Peliculas.objects.get(id=valoracion.pelicula_id)
            valoraciones.append((pelicula,valoracion.valoracion))
        page = request.GET.get('page')
        valoraciones_pag = functions.paginador(valoraciones, page)
        return render(request, 'valoraciones_user.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'valoraciones':valoraciones_pag, 'usuario':usuario})
    else:
        return HttpResponseRedirect('/home/')

@login_required(login_url='/home/')
def criticas_user(request):
    global ranking_first_5, generos
    if 'u' in request.GET or 'page' in request.GET:
        user_id = int(request.GET['u'])
        usuario = User.objects.get(id=user_id)
        criticas_db = models.Criticas.objects.filter(usuario_id=user_id).order_by("-id")
        criticas = []
        for critica in criticas_db:
            pelicula = models.Peliculas.objects.get(id=critica.pelicula_id)
            valoracion = models.Valoraciones.objects.get(id=critica.nota_id)
            criticas.append((pelicula,critica,valoracion.valoracion))
        page = request.GET.get('page')
        criticas_pag = functions.paginador(criticas, page)
        return render(request, 'criticas_user.html', {'lista_peliculas':ranking_first_5, 'lista_generos':generos, 'criticas':criticas_pag, 'usuario':usuario})
    else:
        return HttpResponseRedirect('/home/')
    
@login_required(login_url='/home/')
def configuracion(request):
    global ranking_first_5, generos
        
    if request.method == 'POST':
        form = forms.ConfigForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            usuario_db = User.objects.get(id=request.user.id)
            datos_actualizados = []
            if cd['passwd1'] != '':
                usuario_db.set_password(cd['passwd1'])
                usuario_db.save() 
                datos_actualizados.append('Contraseña')
            if usuario_db.first_name != cd['first_name']:
                User.objects.filter(id=request.user.id).update(first_name=cd['first_name'])
                datos_actualizados.append('Nombre')
            if usuario_db.last_name != cd['last_name']:
                User.objects.filter(id=request.user.id).update(last_name=cd['last_name'])
                datos_actualizados.append('Apellidos')
            if usuario_db.email != cd['email']:
                User.objects.filter(id=request.user.id).update(email=cd['email'])
                datos_actualizados.append('E-mail')             
            return render(request, 'configuracion_confirmacion.html', {'lista_peliculas': ranking_first_5, 'lista_generos':generos, 'datos_actualizados':datos_actualizados})
    else:
        form = forms.ConfigForm(initial={'first_name':request.user.first_name, 'last_name':request.user.last_name, 'email':request.user.email})
    return render(request, 'configuracion.html', {'lista_peliculas': ranking_first_5, 'lista_generos':generos, 'form':form})    

@login_required(login_url='/home/')
def amistades(request):
    global ranking_first_5, generos
    if 'u' in request.GET or 'page' in request.GET:
        usuario_id = int(request.GET['u'])
        usuario = User.objects.get(id=usuario_id)
        borrar = False
        if request.user.id == usuario_id:
            borrar = True
        amistades = models.Amistades.objects.filter(user1_id=usuario_id).order_by('user2')
        amigos = []
        for amistad in amistades:
            amigo = User.objects.get(id=amistad.user2_id)
            num_criticas = models.Criticas.objects.filter(usuario_id=amigo.id).count()
            num_valoraciones = models.Valoraciones.objects.filter(usuario_id=amigo.id).count()
            amigos.append((amigo,num_criticas,num_valoraciones))
        page = request.GET.get('page')
        amigos_pag = functions.paginador(amigos, page)
        return render(request, 'amistades.html', {'lista_peliculas': ranking_first_5, 'lista_generos':generos, 'usuario':usuario, 'amigos':amigos_pag, 'borrar':borrar}) 
    else:
        return HttpResponseRedirect('/perfil/?u=%d' % request.user.id)
        

@login_required(login_url='/home/')
def amigos_add(request):
    global ranking_first_5, generos
    if request.method == "POST":
        user_id = int(request.POST['u'])
        amigo = User.objects.get(id=user_id)
        amistad = models.Amistades.objects.create(user1_id=request.user.id,user2_id=amigo.id)
        message = "Usuario "+amigo.username+" agregado como amigo."
        return render(request, 'amigos_add_confirmacion.html', {'lista_peliculas': ranking_first_5, 'lista_generos':generos, 'amigo':amigo, 'message':message})
    else:
        return HttpResponseRedirect('/perfil/?u=%d' % request.user.id)
    
@login_required(login_url='/home/')
def amigos_delete(request):
    global ranking_first_5, generos
    if 'u' in request.GET:
        user_id = int(request.GET['u'])
        amigo = User.objects.get(id=user_id)
        return render(request, 'amigos_delete.html', {'lista_peliculas': ranking_first_5, 'lista_generos':generos, 'amigo':amigo})
    else:
        return HttpResponseRedirect('/perfil/?u='+request.user.id)

@login_required(login_url='/home/')   
def amigos_delete_confirmacion(request):
    global ranking_first_5, generos
    if 'u' in request.GET:
        user_id = int(request.GET['u'])
        amigo = User.objects.get(id=user_id)
        amistad = models.Amistades.objects.get(user1_id=request.user.id,user2_id=amigo.id)
        amistad.delete()
        message = "Usuario "+amigo.username+" eliminado como amigo."
        return render(request, 'amigos_delete_confirmacion.html', {'lista_peliculas': ranking_first_5, 'lista_generos':generos, 'amigo':amigo, 'message':message})
    else:
        return HttpResponseRedirect('/perfil/?u='+request.user.id)
        
    
def login_admin(request):
    if request.method == 'POST':
        user_post = passwd_post = ''
        if 'user' in request.POST and 'passwd' in request.POST:
            user_post = request.POST['user']
            passwd_post = request.POST['passwd']
            user = authenticate(username=user_post, password=passwd_post)
            if user is not None:
            # se comprueba si la autenticación es correcta
                if user.is_active:
                    if user.is_superuser:
                        message = "%s se ha autenticado correctamente" % (user.username)
                        # se logea al usuario en el sistema
                        login(request, user)
                    else:
                        message = "Este usuario no tiene permiso para acceder al panel de control"
                else:
                    message = "La contraseña es correcta, pero la cuenta ha sido desactivada"
            else:
                # la autenticación no pudo verificar password y contraseña
                message = "El nombre de usuario o la contraseña son incorrectos"
        return render(request, 'admin/login_admin_confirmacion.html', {'message':message})
    return render(request, 'admin/login_admin.html')

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def logout_admin(request):
    from django.contrib.auth import logout
    
    logout(request)
    return HttpResponseRedirect('/login-admin/')

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_main(request):
    generos_con_peliculas = models.Peliculas.objects.values_list('genero', flat=True).distinct()
    num_peliculas = models.Peliculas.objects.count()
    num_usuarios = User.objects.count()
    generos_peliculas_num = []
        
    for genero_id in generos_con_peliculas:
        genero_selec = models.Generos.objects.get(id=genero_id)
        peliculas_por_genero = models.Peliculas.objects.filter(genero_id=genero_selec.id).order_by('titulo')
        num_peliculas_por_genero = models.Peliculas.objects.filter(genero=genero_selec.id).count()
        generos_peliculas_num.append((genero_selec.nombre_corto,genero_selec.nombre_largo,peliculas_por_genero,num_peliculas_por_genero))    
    
    return render(request, 'admin/admin_main.html', {'num_peliculas':num_peliculas, 'num_usuarios':num_usuarios, 'generos_peliculas_num':sorted(generos_peliculas_num)})
  
@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_peliculas(request):
    if 'o' in request.GET:
        orden = request.GET['o']
        if not orden or orden == "val" or orden == "-val":
            orden = "titulo"
        peliculas = models.Peliculas.objects.order_by(orden)
        valoraciones = []
        for pelicula in peliculas:
            valoraciones.append((pelicula,functions.valoracion(pelicula)))
        if request.GET['o'] == "val":
            valoraciones = sorted(valoraciones, key=operator.itemgetter(1)) 
        elif request.GET['o'] == "-val":
            valoraciones = sorted(valoraciones, key=operator.itemgetter(1), reverse=True)
        orden = request.GET['o']
    else:
        orden = 'titulo'
        peliculas = models.Peliculas.objects.order_by(orden)
        valoraciones = []
        for pelicula in peliculas:
            valoraciones.append((pelicula,functions.valoracion(pelicula)))
    page = request.GET.get('page')
    valoraciones_pag = functions.paginador(valoraciones, page)
    return render(request, 'admin/admin_peliculas.html', {'valoraciones':valoraciones_pag, 'orden':orden})

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_peliculas_search(request):
    message = ''
    if 'pelicula_titulo' in request.POST:
        pelicula_titulo = request.POST['pelicula_titulo']
        peliculas_busqueda = models.Peliculas.objects.filter(titulo__icontains=pelicula_titulo)
    elif 'pelicula_titulo' in request.GET:
        pelicula_titulo = request.GET['pelicula_titulo']
        peliculas_busqueda = models.Peliculas.objects.filter(titulo__icontains=pelicula_titulo)
    else:
        pelicula_titulo = ''
        peliculas_busqueda = models.Peliculas.objects.all()
    if not peliculas_busqueda:
        message = "No se han encontrado coincidencias."
    valoraciones = []
    for pelicula in peliculas_busqueda:
            valoraciones.append((pelicula,functions.valoracion(pelicula)))
    page = request.GET.get('page')
    valoraciones_pag = functions.paginador(valoraciones, page)
    return render(request, 'admin/admin_peliculas_search.html', {'peliculas_search':valoraciones_pag, 'message':message, 'titulo':pelicula_titulo})   

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_peliculas_add(request):
    if request.method == 'POST':
        form = forms.PeliculaAddForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            p = models.Peliculas(titulo=cd['titulo'], director=cd['director'], actores=cd['actores'], anyo=cd['anyo'], nacionalidad=cd['nacionalidad'], productora=cd['productora'], genero_id=cd['genero'], sinopsis=cd['sinopsis'], url_imagen=cd['url_imagen'])
            p.save()
            message = "Película añadida correctamente."
            return render(request, 'admin/admin_peliculas_add_confirmacion.html', {'message':message})
    else:
        form = forms.PeliculaAddForm()
    return render(request, 'admin/admin_peliculas_add.html', {'form':form})

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_peliculas_mod(request):
    if request.method == 'POST':
        form = forms.PeliculaAddForm(request.POST)
        pelicula_id = int(request.POST['pelicula_id'])
        pelicula_db = models.Peliculas.objects.get(id=pelicula_id)
        if form.is_valid():
            cd = form.cleaned_data
            datos_actualizados = []
            if pelicula_db.titulo != cd['titulo']:
                models.Peliculas.objects.filter(id=pelicula_id).update(titulo=cd['titulo'])
                datos_actualizados.append('Título')
            if pelicula_db.director != cd['director']:
                models.Peliculas.objects.filter(id=pelicula_id).update(director=cd['director'])
                datos_actualizados.append('Director')
            if pelicula_db.actores != cd['actores']:
                models.Peliculas.objects.filter(id=pelicula_id).update(actores=cd['actores'])
                datos_actualizados.append('Actores')
            if pelicula_db.anyo != cd['anyo']:
                models.Peliculas.objects.filter(id=pelicula_id).update(anyo=cd['anyo'])
                datos_actualizados.append('Año')
            if pelicula_db.nacionalidad != cd['nacionalidad']:
                models.Peliculas.objects.filter(id=pelicula_id).update(nacionalidad=cd['nacionalidad'])
                datos_actualizados.append('Nacionalidad')
            if pelicula_db.productora != cd['productora']:
                models.Peliculas.objects.filter(id=pelicula_id).update(productora=cd['productora'])
                datos_actualizados.append('Productora')
            if pelicula_db.genero_id != int(cd['genero']):
                models.Peliculas.objects.filter(id=pelicula_id).update(genero=cd['genero'])
                datos_actualizados.append('Género')
            if pelicula_db.sinopsis != cd['sinopsis']:
                models.Peliculas.objects.filter(id=pelicula_id).update(sinopsis=cd['sinopsis'])
                datos_actualizados.append('Sinopsis')
            if pelicula_db.url_imagen != cd['url_imagen']:
                models.Peliculas.objects.filter(id=pelicula_id).update(url_imagen=cd['url_imagen'])
                datos_actualizados.append('URL Imagen')
            return render(request, 'admin/admin_peliculas_mod_confirmacion.html', {'datos_actualizados':datos_actualizados})
        else:
            return render(request, 'admin/admin_peliculas_mod.html', {'form':form, 'pelicula':pelicula_db})
    else:
        if 'p' in request.GET:
            p = int(request.GET['p'])
            pelicula = models.Peliculas.objects.get(id=p)
            form = forms.PeliculaAddForm(initial={'titulo':pelicula.titulo, 'director':pelicula.director, 'actores':pelicula.actores, 'anyo':pelicula.anyo, 'nacionalidad':pelicula.nacionalidad, 'productora':pelicula.productora, 'genero':pelicula.genero_id, 'sinopsis':pelicula.sinopsis, 'url_imagen':pelicula.url_imagen})
            return render(request, 'admin/admin_peliculas_mod.html', {'form':form, 'pelicula':pelicula})
        else:
            return HttpResponseRedirect("/admin-peliculas/")

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_peliculas_delete(request):
    if 'p' in request.GET:
        pelicula_id = int(request.GET['p'])
        pelicula = models.Peliculas.objects.get(id=pelicula_id)
        return render(request, 'admin/admin_peliculas_delete.html', {'pelicula':pelicula})
    else:
        return HttpResponseRedirect('/admin-peliculas/')

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')   
def admin_peliculas_delete_confirmacion(request):
    if 'p' in request.GET:
        pelicula_id = int(request.GET['p'])
        pelicula = models.Peliculas.objects.get(id=pelicula_id)
        valoraciones = models.Valoraciones.objects.filter(pelicula_id=pelicula.id)
        valoraciones.delete()
        criticas = models.Criticas.objects.filter(pelicula_id=pelicula.id)
        criticas.delete()
        pelicula.delete()
        message = "La película ha sido eliminada con éxito."
        return render(request, 'admin/admin_peliculas_delete_confirmacion.html', {'message':message})
    else:
        return HttpResponseRedirect('/admin-peliculas/')

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_usuarios(request):
    if 'o' in request.GET:
        orden = request.GET['o']
        if not orden or orden == "rol" or orden == "-rol":
            orden = "username"
        usuarios_db = User.objects.order_by(orden)
        usuarios = []
        for usuario in usuarios_db:
            if usuario.is_superuser:
                rol = 'Administrador'
            else:
                rol = 'Registrado'
            usuarios.append((usuario,rol))
        if request.GET['o'] == "rol":
            usuarios = sorted(usuarios, key=operator.itemgetter(1)) 
        elif request.GET['o'] == "-rol":
            usuarios = sorted(usuarios, key=operator.itemgetter(1), reverse=True)
        orden = request.GET['o']
    else:
        orden = 'username'
        usuarios_db = User.objects.order_by(orden)
        usuarios = []
        for usuario in usuarios_db:
            if usuario.is_superuser:
                rol = 'Administrador'
            else:
                rol = 'Registrado'
            usuarios.append((usuario,rol))
    page = request.GET.get('page')
    usuarios_pag = functions.paginador(usuarios, page)
    return render(request, 'admin/admin_usuarios.html', {'usuarios':usuarios_pag, 'orden':orden})

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_usuarios_search(request):
    message = ''
    if 'username' in request.POST:
        name = request.POST['username']
        usuarios_busqueda = User.objects.filter(username__icontains=name)
    elif 'username' in request.GET:
        name = request.GET['username']
        usuarios_busqueda = User.objects.filter(username__icontains=name)
    else:
        name = ''
        usuarios_busqueda = User.objects.all()
    usuarios = []
    if not usuarios_busqueda:
        message = "No se han encontrado coincidencias."
    else:
        for usuario in usuarios_busqueda:
            if usuario.is_superuser:
                rol = 'Administrador'
            else:
                rol = 'Registrado'
            usuarios.append((usuario,rol))
    page = request.GET.get('page')
    usuarios_pag = functions.paginador(usuarios, page)
    return render(request, 'admin/admin_usuarios_search.html', {'usuarios_search':usuarios_pag, 'message':message, 'name':name})   

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_usuarios_mod(request):
    if request.method == 'POST':
        form = forms.AdminModUserForm(request.POST)
        usuario_db = User.objects.get(id=int(request.POST['usuario_id']))
        if form.is_valid():
            cd = form.cleaned_data
            if usuario_db.is_superuser:
                rol = 'admin'
            else:
                rol = 'reg'
            datos_actualizados = []
            if cd['passwd1'] != '':
                usuario_db.set_password(cd['passwd1'])
                usuario_db.save() 
                datos_actualizados.append('Contraseña')
            if usuario_db.first_name != cd['first_name']:
                User.objects.filter(id=usuario_db.id).update(first_name=cd['first_name'])
                datos_actualizados.append('Nombre')
            if usuario_db.last_name != cd['last_name']:
                User.objects.filter(id=usuario_db.id).update(last_name=cd['last_name'])
                datos_actualizados.append('Apellidos')
            if usuario_db.email != cd['email']:
                User.objects.filter(id=usuario_db.id).update(email=cd['email'])
                datos_actualizados.append('E-mail')
            if rol != cd['rol']:
                if cd['rol'] == 'admin':
                    User.objects.filter(id=usuario_db.id).update(is_superuser=1,is_staff=1)
                else:
                    User.objects.filter(id=usuario_db.id).update(is_superuser=0,is_staff=0)
                datos_actualizados.append('Rol')             
            return render(request, 'admin/admin_usuarios_mod_confirmacion.html', {'datos_actualizados':datos_actualizados, 'usuario':usuario_db})
        else:
            return render(request, 'admin/admin_usuarios_mod.html', {'form':form, 'usuario':usuario_db})
    else:
        if 'u' in request.GET:
            usuario_id = int(request.GET['u'])
            usuario = User.objects.get(id=usuario_id)
            if usuario.is_superuser:
                rol = 'admin'
            else:
                rol = 'reg'
            form = forms.AdminModUserForm(initial={'first_name':usuario.first_name, 'last_name':usuario.last_name, 'email':usuario.email, 'rol':rol})
            return render(request, 'admin/admin_usuarios_mod.html', {'form':form, 'usuario':usuario})
        else:
            return HttpResponseRedirect('/admin-usuarios/')
        
@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_usuarios_ver(request):
    if 'u' in request.GET:
        usuario_id = int(request.GET['u'])
        usuario = User.objects.get(id=usuario_id)
        criticas = models.Criticas.objects.filter(usuario_id=usuario.id).order_by('id')
        criticas_val = []
        for critica in criticas:
            pelicula = models.Peliculas.objects.get(id=critica.pelicula_id)
            valoracion = models.Valoraciones.objects.get(id=critica.nota_id)
            criticas_val.append((critica,pelicula,valoracion.valoracion))
        page = request.GET.get('page')
        criticas_pag = functions.paginador(criticas_val, page)
        return render(request, 'admin/admin_usuarios_ver.html', {'usuario':usuario, 'criticas':criticas_pag})
    else:
        return HttpResponseRedirect("/admin-usuarios/")

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')    
def admin_usuarios_ver_search(request):
    if 'usuario_id' in request.POST and 'critica_titulo' in request.POST:
        usuario_id = int(request.POST['usuario_id'])
        critica_titulo = request.POST['critica_titulo']
    elif 'usuario_id' in request.GET and 'critica_titulo' in request.GET:
        usuario_id = int(request.GET['usuario_id'])
        critica_titulo = request.GET['critica_titulo']
    else:
        return HttpResponseRedirect("/admin-usuarios/")
    usuario = User.objects.get(id=usuario_id)
    criticas = models.Criticas.objects.filter(usuario_id=usuario.id,titulo__icontains=critica_titulo)
    criticas_val = []
    message = ''
    if criticas:
        for critica in criticas:
            pelicula = models.Peliculas.objects.get(id=critica.pelicula_id)
            valoracion = models.Valoraciones.objects.get(id=critica.nota_id)
            criticas_val.append((critica,pelicula,valoracion.valoracion))
    else:
        message = 'No se han encontrado coincidencias'
    page = request.GET.get('page')
    criticas_pag = functions.paginador(criticas_val, page)
    return render(request, 'admin/admin_usuarios_ver_search.html', {'usuario':usuario, 'criticas':criticas_pag, 'message':message, 'critica_titulo':critica_titulo})

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_usuarios_delete(request):
    if 'u' in request.GET:
        usuario_id = int(request.GET['u'])
        usuario = User.objects.get(id=usuario_id)
        return render(request, 'admin/admin_usuarios_delete.html', {'usuario':usuario})
    else:
        return HttpResponseRedirect('/admin-usuarios/')

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')   
def admin_usuarios_delete_confirmacion(request):
    if 'u' in request.GET:
        usuario_id = int(request.GET['u'])
        usuario = User.objects.get(id=usuario_id)
        if usuario.id == request.user.id:
            message = "No se puede borrar a su propio usuario."
        else:
            valoraciones = models.Valoraciones.objects.filter(usuario_id=usuario.id)
            valoraciones.delete()
            criticas = models.Criticas.objects.filter(usuario_id=usuario.id)
            criticas.delete()
            usuario.delete()
            message = "El usuario ha sido eliminado con éxito."
        return render(request, 'admin/admin_usuarios_delete_confirmacion.html', {'message':message})
    else:
        return HttpResponseRedirect('/admin-usuarios/')

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_usuarios_add(request):
    error = ""
    if request.method == "POST":
        form = forms.AdminAddUserForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            if User.objects.filter(username=cd['username']).count():
                error = "El nombre de usuario ya existe"
            else:
                new_user = User()
                new_user.username = cd['username']
                new_user.first_name = cd['first_name']
                new_user.last_name = cd['last_name']
                new_user.email = cd['email']
                new_user.set_password(cd['passwd1'])
                if cd['rol'] == "admin":
                    new_user.is_staff = 1
                    new_user.is_superuser = 1
                new_user.save()
                message = "Usuario añadido con éxito."
                return render(request, 'admin/admin_usuarios_add_confirmacion.html', {'message':message})
    else:
        form = forms.AdminAddUserForm()
    return render(request, 'admin/admin_usuarios_add.html', {'form':form, 'error':error})

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_peliculas_ver(request):
    if 't' in request.GET:
        pelicula_id = int(request.GET['t'])
        pelicula = models.Peliculas.objects.get(id=pelicula_id)
        pelicula_valoracion = functions.valoracion(pelicula)
        criticas = models.Criticas.objects.filter(pelicula_id=pelicula.id).order_by('id')
        criticas_val = []
        for critica in criticas:
            valoracion = models.Valoraciones.objects.get(id=critica.nota_id)
            criticas_val.append((critica,valoracion.valoracion))
        page = request.GET.get('page')
        criticas_pag = functions.paginador(criticas_val, page)
        return render(request, 'admin/admin_peliculas_ver.html', {'pelicula':pelicula, 'criticas':criticas_pag, 'pelicula_valoracion':pelicula_valoracion})
    else:
        return HttpResponseRedirect("/admin-peliculas/")

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_peliculas_ver_search(request):
    if 'pelicula_id' in request.POST and 'critica_titulo' in request.POST:
        pelicula_id = int(request.POST['pelicula_id'])
        critica_titulo = request.POST['critica_titulo']
    elif 'pelicula_id' in request.GET and 'critica_titulo' in request.GET:
        pelicula_id = int(request.GET['pelicula_id'])
        critica_titulo = request.GET['critica_titulo']
    else:
        return HttpResponseRedirect("/admin-peliculas/")
    pelicula = models.Peliculas.objects.get(id=pelicula_id)
    criticas = models.Criticas.objects.filter(pelicula_id=pelicula.id,titulo__icontains=critica_titulo)
    criticas_val = []
    message = ''
    if criticas:
        for critica in criticas:
            valoracion = models.Valoraciones.objects.get(id=critica.nota_id)
            criticas_val.append((critica,valoracion.valoracion))
    else:
        message = 'No se han encontrado coincidencias'
    page = request.GET.get('page')
    criticas_pag = functions.paginador(criticas_val, page)
    return render(request, 'admin/admin_peliculas_ver_search.html', {'pelicula':pelicula, 'criticas':criticas_pag, 'message':message, 'critica_titulo':critica_titulo})

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_criticas(request):
    if 'c' in request.GET:
        critica_id = int(request.GET['c'])
        critica = models.Criticas.objects.get(id=critica_id)
        nota = models.Valoraciones.objects.get(id=critica.nota_id)
        pelicula = models.Peliculas.objects.get(id=critica.pelicula_id)
        usuario = User.objects.get(id=critica.usuario_id)
        return render(request, 'admin/admin_criticas.html', {'critica':critica, 'nota':nota.valoracion, 'pelicula':pelicula, 'usuario':usuario})
    else:
        return HttpResponseRedirect("/admin-main/")

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_criticas_mod(request):
    if request.method == 'POST':
        form = forms.CriticaModForm(request.POST)
        critica_id = int(request.POST['critica_id'])
        critica_db = models.Criticas.objects.get(id=critica_id)
        if form.is_valid():
            cd = form.cleaned_data
            datos_actualizados = []
            if critica_db.titulo != cd['titulo']:
                models.Criticas.objects.filter(id=critica_id).update(titulo=cd['titulo'])
                datos_actualizados.append('Título')
            if critica_db.contenido != cd['contenido']:
                models.Criticas.objects.filter(id=critica_id).update(contenido=cd['contenido'])
                datos_actualizados.append('Contenido')
            return render(request, 'admin/admin_criticas_mod_confirmacion.html', {'datos_actualizados':datos_actualizados, 'critica':critica_db})
        else:
            return render(request, 'admin/admin_criticas_mod.html', {'form':form, 'critica':critica_db})
    else:
        if 'c' in request.GET:
            c = int(request.GET['c'])
            critica = models.Criticas.objects.get(id=c)
            form = forms.CriticaModForm(initial={'titulo':critica.titulo, 'contenido':critica.contenido})
            return render(request, 'admin/admin_criticas_mod.html', {'form':form, 'critica':critica})
        else:
            return HttpResponseRedirect("/admin-main/")

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')
def admin_criticas_delete(request):
    if 'c' in request.GET:
        previous = request.GET['previous']
        critica_id = int(request.GET['c'])
        critica = models.Criticas.objects.get(id=critica_id)
        return render(request, 'admin/admin_criticas_delete.html', {'critica':critica, 'previous':previous})
    else:
        return HttpResponseRedirect('/admin-main/')

@user_passes_test(lambda u: u.is_superuser, login_url='/login-admin/')   
def admin_criticas_delete_confirmacion(request):
    if 'c' in request.GET:
        previous = request.GET['previous']
        critica_id = int(request.GET['c'])
        critica = models.Criticas.objects.get(id=critica_id)
        critica.delete()
        message = "La crítica ha sido eliminada con éxito."
        return render(request, 'admin/admin_criticas_delete_confirmacion.html', {'message':message, 'previous':previous})
    else:
        return HttpResponseRedirect('/admin-main/')
